1. Technical Field
The present invention relates in general to a method and system for dynamically packaging component objects. More particularly, the present invention relates to a system and method packaging objects corresponding to a client request and returning the packaged objects to the client.
2. Description of the Related Art
Computer networks, such as the Internet, typically include client computer (those that request information) and server computers (those that provide information in response to requests). Software called a “browser” provides interactive sessions between clients and servers. Common browser software includes Netscape's Navigator™ software and Microsoft's Internet Explorer™ software.
Originally, servers provided static text, or “web pages” to clients which were displayed in the client's web browsers. Soon after introducing static web pages, however, it became increasingly desirable to provide web pages with dynamic content, for example to display a customer's current account balance. Web servers provided public interfaces so that applications could interface (“plug-in”) and collaborate with the web servers to provide the client browsers web pages with dynamic content. As a group, these applications became known as “application servers.” Public specifications (the “J2EE Specification”) have been provided by Sun Microsystems so that applications built to the specification can be ported from one application server to another.
Application servers include a Java object called a “servlet” which is invoked in response to a request that passes from the client to the server to the application server. The servlet is provided information pertaining to the request as well as an object that encapsulates the response stream back to the client. By using servlet logic developers have control over how a request is processed as well as what information is sent back to the client.
Over time the servlet model proved to be quite powerful. A simple interface existed to a class that could invoke complex logic and reuse any number of system components. One drawback, however, was that developers often coded large portions of static text to accompany a relative small amount of dynamic information. Using servlets, static text is encoded in “write statements” which was more challenging than working with the same static text in a hypertext markup language (HTML) file.
This challenge was addressed with the introduction of Java Server Pages (JSP). JSPs were essentially text macro files that were resolved dynamically into servlets. A JSP source file looks like an HTML file with the addition of embedded Java code. When the page is requested by a client, the JSP source is transformed into a servlet that writes the static text to the response while invoking the Java code to write dynamic content to the response.
Java Server Pages, however, introduced additional challenges to the development environment. While JSP was quite powerful, it increased the skills needed to prepare pages from those of a simple HTML author to those of a Java developer. In development environments, lower amounts of skills were needed to code HTML documents resulting in more employees capable of writing HTML documents. However, Java development required a higher amount of programming skills. Java development skills in development environments is often in short supply and provided by a higher paid Java programmer, while HTML page design skills can be provided by lower paid and less skilled Web page designers.
To address this challenge has been the introduction of “custom tags.” Skilled Java programmers can now place the logic that formerly was embedded in Java statements in JSP documents into custom tag files. Web page designers are then able to place the custom tags in Java Server Pages. The custom tags appear much like other HTML or Extended Markup Language (XML) tags which are easier for Web page designers to incorporate into Web pages.
The introduction of custom tags, however, introduced a new set of challenges for application developers. For each custom tag that is to be used in Web pages, there are two classes (a tag handler class and a tag extra information (TEI) class) that are implemented in addition to an XML file that provides parsing information, nesting behavior, and attribute descriptions for the custom tag. The framework for each of these files changes depending on the actions that the custom tags are going to perform. Developers implement the framework in the custom tag files before writing the customized business logic code that will actually perform a particular business function (i.e., look up a customer's account balance).
What is needed, therefore, is a system and method for receiving general tag information from a developer and creating custom tag files that include a framework for implementing the custom tags. The developer should be able to use the resulting files to code particular business logic pertaining to the custom tags.
An additional challenge includes packaging the resulting custom tag files to dynamically provide the developer with the custom tag files. In a client-server environment, the developer would request the custom tag framework files from a server application. Based on the developer's needs, the server would dynamically generate the custom tag files. Traditionally, these files could be placed in a server area that would later be downloaded from the server area using the file transfer protocol (FTP).
What is needed, therefore, is a system and method for dynamically packaging any number of components into a package and providing the resulting package to the client through familiar interface.